package models

import (
	"database/sql"
	"fmt"
	"time"
)

type Favorite struct {
	UserID    		int 		`json:"user_id"`		// 用户ID
}

type FavoriteItem struct {
	FavoriteID 		int 		`json:"favorite_id"`	// 收藏夹ID
	ProductID 		int 		`json:"product_id"`		// 商品ID

    ProductName 	string 		`json:"productname"`	// 商品名称
    ImageURL    	string 		`json:"image_url"`  	// 商品图片URL
	Price     		float64 	`json:"price"`      	// 商品单价
    Shop        	string  	`json:"shop"`           // 店家
	CollectDate		time.Time	`json:"collectdate"`   	// 收藏时间
	// CollectDate长这样：2024-12-19T00:00:00Z
}

func AddToFavorite(userID int, productID int) (int64, error) {
	// 调用 checkExists 检查用户或商品是否存在
	if _, err := checkExists(userID, productID); err != nil {
		return 0, fmt.Errorf("%v", err)
	}

	var FavoriteID int
	// 开启事务
	tx, err := db.Begin()
	if err != nil {
		return 0, err
	}
	defer tx.Rollback()

	// 检查收藏夹是否存在，如果不存在则创建
	err = tx.QueryRow("SELECT user_id FROM favorites WHERE user_id =?", userID).Scan(&FavoriteID)
	if err != nil {
		if err == sql.ErrNoRows {
			// 创建新的收藏夹
			_, err = tx.Exec("INSERT INTO favorites(user_id) VALUES (?)", userID)
			if err!= nil {
				return 0, err
			}
			FavoriteID = userID
		} else {
			return 0, err
		}
	}

	// 检查商品是否已存在于收藏夹中
	var existing int
	err = tx.QueryRow("SELECT collectdate FROM favorite_items WHERE favorite_id =? AND product_id =?", FavoriteID, productID).Scan(&existing)
	if err != nil {
		if err == sql.ErrNoRows {
			// 商品不存在于收藏夹中，插入新的收藏项
			_, err = tx.Exec(
				"INSERT INTO favorite_items(favorite_id, product_id, collectdate) VALUES(?, ?, ?)",
				FavoriteID, productID, time.Now(),
			)
			if err!= nil {
				return 0, err
			}
		} else {
			// 商品已存在于收藏夹中，更新日期
			_, err = tx.Exec(
				"UPDATE favorite_items SET collectdate = ? WHERE favorite_id = ? AND product_id = ?",
				time.Now(), FavoriteID, productID,
			)
			if err != nil {
				return 0, err
			}
		}
	} 

	// 提交事务
	if err = tx.Commit(); err!= nil {
		return 0, err
	}
	return int64(FavoriteID), nil
}

// 获取指定用户ID的收藏夹信息
func GetFavoriteByUserID(userID int) (Favorite, []FavoriteItem, error) {
    var favorite Favorite

	// 首先检查用户是否存在
	_, err := GetUserByID(userID)
	if err != nil {
		// 如果用户不存在，返回相应的错误
		return favorite, nil, fmt.Errorf("用户不存在: %v", err)
	}

	// 获取收藏夹基本信息
	err = db.QueryRow("SELECT user_id FROM favorites WHERE user_id = ?", userID).Scan(&favorite.UserID)
	if err != nil {
		if err == sql.ErrNoRows {
            // 若收藏夹不存在，创建一个新的收藏夹
			_, err = db.Exec("INSERT INTO favorites(user_id) VALUES(?)", userID)
			if err != nil {
				return favorite, nil, err
			}
			favorite.UserID = userID
			return favorite, []FavoriteItem{}, nil
		}
		return favorite, nil, err
	}

    // 获取收藏夹中的商品信息
	rows, err := db.Query(`
		SELECT fi.favorite_id, fi.product_id, p.productname, p.image_url,
			p.price, p.shop, fi.collectdate
		FROM favorite_items fi
		JOIN products p ON fi.product_id = p.id
		WHERE fi.favorite_id = ?`, userID)
	if err != nil{
		return favorite, nil, err
	}
	defer rows.Close()

	var favoriteItems []FavoriteItem
	for rows.Next() {
		var item FavoriteItem
		var price float64
		var productName, imageURL, shop string
		err := rows.Scan(
			&item.FavoriteID, &item.ProductID, &productName, &imageURL, &price, &shop, &item.CollectDate)
		if err!= nil {
			return favorite, nil, err
		}
		item.ProductName = productName
		item.ImageURL = imageURL
		item.Shop = shop
		item.Price = price
		favoriteItems = append(favoriteItems, item)
	}

	return favorite, favoriteItems, nil
}


func DeleteFromFavorite(userID int, productID int) (int64, error) {
	// 调用 checkExists 检查用户或商品是否存在
	if _, err := checkExists(userID, productID); err != nil {
		return 0, fmt.Errorf("%v", err)
	}

	// 开启事务
	tx, err := db.Begin()
	if err!= nil {
		return 0, fmt.Errorf("开启事务失败: %v", err)
	}
	defer tx.Rollback()

	// 删除收藏夹中的商品
	result, err := tx.Exec("DELETE FROM favorite_items WHERE favorite_id =? AND product_id =?",
		userID, productID)
	if err != nil {
		return 0, fmt.Errorf("删除商品失败: %v", err)
	}

	// 获取删除的行数
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return 0, fmt.Errorf("获取影响行数失败: %v", err)
	}
	
	// 提交事务
	if err = tx.Commit(); err!= nil {
		return 0, fmt.Errorf("提交事务失败: %v", err)
	}
	
	return rowsAffected, nil
}

func checkExists(userID int, productID int) (int64, error) {
	// 首先检查用户是否存在
	_, err := GetUserByID(userID)
	if err != nil {
		return 0, fmt.Errorf("用户不存在")
	}

	// 检查商品是否存在并获取
	product, err := GetProductByID(productID)
	if err != nil {
		return 0, err
	}
	if product.ID == 0 {
		return 0, fmt.Errorf("商品不存在")
	}

	return 1, nil
}